Basic operations

Learn the fundamental operations in PVAC-HFHE including key generation, encryption, and decryption

This guide covers the essential operations you’ll use in every PVAC-HFHE application. You’ll learn how to set up the cryptographic system, encrypt data, and decrypt results.

Overview

Every PVAC-HFHE workflow follows these steps:

1. Generate keys

   Create public and secret keys using the keygen function

2. Encrypt data

   Convert plaintext values to ciphertexts using enc_value

3. Perform operations

   Execute homomorphic operations on encrypted data

4. Decrypt results

   Recover plaintext values using dec_value

Setting up the cryptographic context

Every PVAC-HFHE application starts by generating cryptographic keys:

#include <pvac/pvac.hpp>
using namespace pvac;

int main() {
    // Initialize parameters, public key, and secret key
    Params prm;
    PubKey pk;
    SecKey sk;
    
    // Generate keys
    keygen(prm, pk, sk);
    
    return 0;
}

The keygen function takes approximately 859ms according to benchmark data. This is a one-time operation per session.

Encrypting values

Use enc_value to encrypt 64-bit unsigned integers:

// Encrypt a single value
uint64_t plaintext = 42;
Cipher ciphertext = enc_value(pk, sk, plaintext);

Example from source

From examples/basic_usage.cpp:59-63:

uint64_t a = 42, b = 17;
Cipher ca = enc_value(pk, sk, a);
Cipher cb = enc_value(pk, sk, b);
CHECK(dec_value(pk, sk, ca).lo == a, "dec(42) = 42");
CHECK(dec_value(pk, sk, cb).lo == b, "dec(17) = 17");

Decrypting values

The dec_value function returns a field element Fp with two components:

Fp result = dec_value(pk, sk, ciphertext);
uint64_t plaintext_value = result.lo;  // Lower 64 bits

Always use the .lo field of the returned Fp struct to extract the uint64 value. The .hi field contains upper bits of the 127-bit field element.

Testing encryption correctness

Verify your encryption pipeline with special values:

// Test zero
Cipher c0 = enc_value(pk, sk, 0);
assert(dec_value(pk, sk, c0).lo == 0);

// Test one
Cipher c1 = enc_value(pk, sk, 1);
assert(dec_value(pk, sk, c1).lo == 1);

// Test large values
uint64_t large = 123456789;
Cipher c_large = enc_value(pk, sk, large);
assert(dec_value(pk, sk, c_large).lo == large);

From examples/basic_usage.cpp:66-70:

Cipher c0 = enc_value(pk, sk, 0);
Cipher c1 = enc_value(pk, sk, 1);
CHECK(dec_value(pk, sk, c0).lo == 0, "dec(0) = 0");
CHECK(dec_value(pk, sk, c1).lo == 1, "dec(1) = 1");

Performance characteristics

Based on benchmark data:

Operation	Time	Notes
keygen	859ms	One-time setup
enc_value	84ms	Per encryption
dec_value	13ms	Per decryption

Fresh ciphertexts are only 42 KB in size, which is 6-85x smaller than comparable RLWE schemes like BFV and CKKS.

Verifying randomness

Encryptions of the same value produce different ciphertexts due to randomization:

Cipher ca1 = enc_value(pk, sk, 100);
Cipher ca2 = enc_value(pk, sk, 100);

// Same plaintext
assert(dec_value(pk, sk, ca1).lo == dec_value(pk, sk, ca2).lo);

// Different ciphertext representation
assert(ca1.E[0].w[0].lo != ca2.E[0].w[0].lo);

From examples/basic_usage.cpp:216-221:

Cipher ca1 = enc_value(pk, sk, 100);
Cipher ca2 = enc_value(pk, sk, 100);
CHECK(dec_value(pk, sk, ca1).lo == dec_value(pk, sk, ca2).lo, "both = 100");
CHECK(ca1.E[0].w[0].lo != ca2.E[0].w[0].lo, "diff rnd");

Next steps

Key generation

Deep dive into parameters and key structures

Arithmetic operations

Learn ct_add, ct_mul, and ct_sub